package com.project.personal_blog.garbage_classification_management_system.Controller;

import com.project.personal_blog.garbage_classification_management_system.pojo.Code;
import com.project.personal_blog.garbage_classification_management_system.pojo.Result;
import com.project.personal_blog.garbage_classification_management_system.pojo.garbageType;
import com.project.personal_blog.garbage_classification_management_system.service.GarbageTypeService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;

import java.util.List;

@RestController
@RequestMapping("/root/garbageType")
public class GarbageTypeController {
    @Autowired
    private GarbageTypeService garbageTypeService;

    // 查询所有垃圾类型
    @GetMapping("/select/all")
    public ResponseEntity<Result> selectAll() {
        // 定义结果集
        Result result;
        // 调用垃圾类型服务的selectAll方法，查询所有垃圾类型
        List<garbageType> garbageTypes = garbageTypeService.selectAll();
        // 如果垃圾类型列表为空，则返回一个Result对象，表示查询失败
        if (garbageTypes.isEmpty()) {
            result = new Result(false, "没有垃圾类型");
        } else {
            // 否则，返回一个Result对象，表示查询成功
            result = new Result("查询成功", Code.SELECT_SUCCESS, garbageTypes);
        }
        // 返回一个ResponseEntity对象，包含查询结果
        return ResponseEntity.ok(result);
    }


    // 根据id查询垃圾类型
 @GetMapping("/select/{id}")
    public ResponseEntity<Result> selectById(@PathVariable Integer id) {
        // 定义结果集
        Result result;
        // 根据id查询垃圾类型
        garbageType garbageType = garbageTypeService.selectById(id);
        // 如果没有查到，则返回错误信息
        if (garbageType == null) {
            result = new Result(false, "没有该垃圾类型");
        } else {
            // 如果查到，则返回查询成功，以及垃圾类型信息
            result = new Result("查询成功", Code.SELECT_SUCCESS, garbageType);
        }
        // 返回结果
        return ResponseEntity.ok(result);
    }

    // 添加垃圾类型
    @PostMapping("/add")
    public ResponseEntity<Result> insert(@RequestBody garbageType garbageType) {
        // 创建一个Result对象
        Result result;
        // 调用garbageTypeService的insert方法，传入garbageType，判断返回值是否为false
        boolean b = garbageTypeService.insert(garbageType);
        // 如果返回值为false，则创建一个Result对象，并将返回的false赋值给result的success属性，并将"添加失败"赋值给result的message属性
        if (!b) {
            result = new Result(false, "添加失败");
        } else {
            // 如果返回值为true，则创建一个Result对象，并将返回的true赋值给result的success属性，并将"添加成功"赋值给result的message属性，并将garbageType赋值给result的data属性
            result = new Result("添加成功", Code.ADD_SUCCESS, garbageType);
        }
        // 返回一个ResponseEntity对象，并将result作为参数传入
        return ResponseEntity.ok(result);
    }

    // 修改垃圾类型
    @PostMapping("/update")
    public ResponseEntity<Result> update(@RequestBody garbageType garbageType) {
        // 创建一个Result对象
        Result result;
        // 调用garbageTypeService的update方法，传入garbageType，返回一个boolean值
        boolean b = garbageTypeService.update(garbageType);
        // 如果返回的boolean值为false，则创建一个Result对象，值为false，描述为"修改失败"
        if (!b) {
            result = new Result(false, "修改失败");
        } else {
        // 如果返回的boolean值为true，则创建一个Result对象，值为true，描述为"修改成功"，Code.UPDATE_SUCCESS，garbageType
            result = new Result("修改成功", Code.UPDATE_SUCCESS, garbageType);
        }
        // 返回一个ResponseEntity对象，状态码为200，携带result对象
        return ResponseEntity.ok(result);
    }

    // 删除垃圾类型
    @DeleteMapping("/delete/{id}")
    public ResponseEntity<Result> deleteById(@PathVariable Integer id) {
        // 根据id查询结果
        Result result;
        boolean b = garbageTypeService.deleteById(id);
        // 如果查询结果为false，则删除失败
        if (!b) {
            result = new Result(false, "删除失败");
        } else {
            // 否则删除成功，返回结果
            result = new Result("删除成功", Code.DELETE_SUCCESS, null);
        }
        // 返回结果
        return ResponseEntity.ok(result);
    }

    // 获取分页垃圾类型
    @GetMapping("/page/{page}/{size}")
    public ResponseEntity<Result> PageSelect(@PathVariable int page, @PathVariable int size) {

        // 定义结果集
        Result result;
        // 根据分页和每页大小查询垃圾类型
        boolean b = garbageTypeService.PageSelect(page, size);
        // 如果查询失败，返回错误信息
        if (!b) {
            result = new Result(false, "没有垃圾类型");
        } else {
            // 查询成功，返回垃圾类型和状态码
            result = new Result("查询成功", Code.SELECT_SUCCESS, b);
        }
        // 返回结果
        return ResponseEntity.ok(result);
    }

    // 根据id排序垃圾类型
    @GetMapping("/sort/{id}")
    public ResponseEntity<Result> sortByIdSelect(@PathVariable int id) {

        // 定义结果集
        Result result;
        // 根据id查询垃圾类型
        boolean b = garbageTypeService.sortByIdSelect(id);
        // 如果查询失败，返回错误信息
        if (!b) {
            result = new Result(false, "没有垃圾类型");
        } else {
            // 查询成功，返回垃圾类型和状态码
            result = new Result("查询成功", Code.SELECT_SUCCESS, b);
        }
        // 返回结果
        return ResponseEntity.ok(result);
    }
}